#include "sqlitemanager.h"
#include <QSqlDatabase>
#include <QSqlQuery>
#include <QDebug>

SqliteManager *SqliteManager::instance = nullptr;

SqliteManager::SqliteManager()
{
    // 初始化SQLite连接
    db = QSqlDatabase::addDatabase("QSQLITE");
    db.setDatabaseName("attend.db"); // 数据库文件路径
    if (!db.open())
    {
        qCritical() << "Failed to open database:" << db.lastError().text();
        return;
    }

    // 创建员工表
    QSqlQuery query(db);
    QString createSql = R"(
                        CREATE TABLE IF NOT EXISTS employee (
                        id INTEGER PRIMARY KEY AUTOINCREMENT,
                        employee_id TEXT UNIQUE NOT NULL, -- 员工号
                        name TEXT NOT NULL,               -- 员工姓名
                        department TEXT,                  -- 部门
                        position TEXT,                    -- 职位
                        photo BLOB                        -- 照片(二进制)
                        )
                        )";
    if (!query.exec(createSql))
    {
        qCritical() << "Create employee table failed:" << query.lastError().text();
    }
    createSql = nullptr;

    createSql = R"(
                CREATE TABLE IF NOT EXISTS attend (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                employee_id TEXT NOT NULL, -- 关联员工表
                record_date TEXT NOT NULL, -- 考勤日期（yyyy-MM-dd，每天一条记录）
                sign_in_time TEXT, -- 签到时间（HH:mm:ss，NULL表示未签到）
                late_minutes INTEGER DEFAULT 0, -- 迟到分钟数（0表示未迟到）
                sign_in_status TEXT NOT NULL, -- 上午考勤状态：正常/缺卡/迟到
                sign_out_time TEXT, -- 签退时间（HH:mm:ss，NULL表示未签退）
                early_minutes INTEGER DEFAULT 0, -- 早退分钟数（0表示未早退）
                sign_out_status TEXT NOT NULL, -- 下午考勤状态：正常/缺卡/早退
                FOREIGN KEY (employee_id) REFERENCES employee(employee_id),
                UNIQUE (employee_id, record_date) -- 确保一人一天一条记录
                )
                )";
    if (!query.exec(createSql))
    {
        qCritical() << "Create attend table failed:" << query.lastError().text();
    }
    createSql = nullptr;

    createSql = R"(
                CREATE TABLE IF NOT EXISTS attendance_rules (
                rule_id INTEGER PRIMARY KEY AUTOINCREMENT,
                rule_name TEXT UNIQUE NOT NULL, -- 规则名称（如：标准工时制、弹性工时制）
                work_start TIME NOT NULL, -- 规定上班时间（如：09:00:00，用于判断迟到）
                work_end TIME NOT NULL, -- 规定下班时间（如：18:00:00，用于判断早退）
                split_time TIME NOT NULL, -- 分隔时间
                checkin_start TIME NOT NULL, -- 最早允许签到时间（如：08:00:00，早于该时间签到无效）
                checkout_end TIME NOT NULL, -- 最晚允许签退时间（如：19:00:00，晚于该时间签退无效）
                is_default INTEGER DEFAULT 0 CHECK(is_default IN (0,1)), -- 1=默认规则，0=非默认
                UNIQUE(rule_name),
                UNIQUE(is_default) -- 确保只有一个默认规则
                )
                )";

    if (!query.exec(createSql))
    {
        qCritical() << "Create attendance_rules table failed:" << query.lastError().text();
    }
    else
    {
        // 插入默认规则（补充新字段的默认值）
        query.clear();
        if (query.exec("SELECT rule_id FROM attendance_rules WHERE is_default = 1"))
        {
            if (!query.next())
            {
                QString insertDefaultSql = R"(
                                           INSERT INTO attendance_rules (
                                           rule_name, checkin_start, work_start, split_time,
                                           work_end, checkout_end, is_default
                                           ) VALUES (
                                           '标准工时制', '08:00:00', '09:00:00','12:00:00', '18:00:00',
                                           '19:00:00', 1
                                           )
                                           )";
                if (query.exec(insertDefaultSql))
                {
                    qDebug() << "Default attendance rule inserted successfully";
                }
                else
                {
                    qWarning() << "Insert default rule failed:" << query.lastError().text();
                }
            }
        }
    }
    createSql = nullptr;
    createSql = R"(
                CREATE TABLE IF NOT EXISTS user (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                username TEXT NOT NULL UNIQUE,
                password text NOT NULL
                )
                )";
    if (!query.exec(createSql)) {
        qCritical() << "Create user table failed:" << query.lastError().text();
    } else {
        // 插入默认管理员账号
        query.clear();
        if (query.exec("SELECT id FROM user WHERE username = 'admin'")) {
            if (!query.next()) { // 不存在则插入
                QString insertAdminSql = R"(
                                         INSERT INTO user (username, password)
                                         VALUES ('admin', '123')
                                         )";
                if (!query.exec(insertAdminSql)) {
                    qWarning() << "Insert default admin failed:" << query.lastError().text();
                } else {
                    qDebug() << "Default admin user inserted";
                }
            }
        }
    }
    createSql = nullptr;
}

SqliteManager *SqliteManager::getInstance()
{
    if (!instance)
    {
        instance = new SqliteManager();
    }
    return instance;
}

SqliteManager::~SqliteManager()
{
    if (db.isOpen())
    {
        db.close();
    }
}

QSqlQuery SqliteManager::execQuery(const QString &sql)
{
    QMutexLocker locker(&mutex);
    QSqlQuery query(db);
    if (!query.exec(sql))
    {
        qWarning() << "Query failed:" << query.lastError().text() << "SQL:" << sql;
    }
    return query;
}

QSqlQuery SqliteManager::execQueryWithParams(const QString &sql,
                                             std::function<bool(QSqlQuery &)> bindParamsFunc)
{
    QMutexLocker locker(&mutex); // 加锁保证线程安全
    QSqlQuery query(db);

    // 准备SQL语句
    if (!query.prepare(sql))
    {
        qWarning() << "SQL prepare failed:" << query.lastError().text() << "SQL:" << sql;
        return query; // 返回空结果
    }

    // 调用外部传入的参数绑定函数
    if (!bindParamsFunc(query))
    {
        qWarning() << "Parameter binding failed for SQL:" << sql;
        return query; // 返回空结果
    }

    // 执行查询
    if (!query.exec())
    {
        qWarning() << "SQL execute failed:" << query.lastError().text() << "SQL:" << sql;
    }

    return query;
}

bool SqliteManager::execNonQuery(const QString &sql)
{
    QMutexLocker locker(&mutex);
    QSqlQuery query(db);
    return query.exec(sql);
}

bool SqliteManager::execNonQueryWithParams(const QString &sql,
                                           std::function<bool(QSqlQuery &)> bindParamsFunc)
{
    QMutexLocker locker(&mutex); // 确保线程安全
    QSqlQuery query(db);

    // 准备 SQL 语句
    if (!query.prepare(sql))
    {
        qWarning() << "SQL prepare failed:" << query.lastError().text();
        return false;
    }

    // 调用外部传入的参数绑定函数
    if (!bindParamsFunc(query))
    {
        qWarning() << "Parameter binding failed";
        return false;
    }

    // 执行查询
    if (!query.exec())
    {
        qWarning() << "SQL execute failed:" << query.lastError().text();
        return false;
    }

    return true;
}
